using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("UniversalInputManager")]
	public class UniversalInputManager : MonoBehaviour
	{
		[Attribute38("UniversalInputManager.TextInputParams")]
		public class TextInputParams : MonoClass
		{
			public GameObject m_owner => method_3<GameObject>("m_owner");

			public bool m_password => method_2<bool>("m_password");

			public bool m_number => method_2<bool>("m_number");

			public bool m_multiLine => method_2<bool>("m_multiLine");

			public Rect m_rect => method_2<Rect>("m_rect");

			public int m_maxCharacters => method_2<int>("m_maxCharacters");

			public string m_text => method_4("m_text");

			public bool m_touchScreenKeyboardHideInput => method_2<bool>("m_touchScreenKeyboardHideInput");

			public int m_touchScreenKeyboardType => method_2<int>("m_touchScreenKeyboardType");

			public bool m_inputKeepFocusOnComplete => method_2<bool>("m_inputKeepFocusOnComplete");

			public bool m_showVirtualKeyboard => method_2<bool>("m_showVirtualKeyboard");

			public bool m_hideVirtualKeyboardOnComplete => method_2<bool>("m_hideVirtualKeyboardOnComplete");

			public bool m_useNativeKeyboard => method_2<bool>("m_useNativeKeyboard");

			public TextInputParams(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TextInputParams(IntPtr address)
				: this(address, "TextInputParams")
			{
			}
		}

		public enum TextInputIgnoreState
		{
			INVALID,
			COMPLETE_KEY_UP,
			CANCEL_KEY_UP,
			NEXT_CALL
		}

		public static float TEXT_INPUT_RECT_HEIGHT_OFFSET => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "TEXT_INPUT_RECT_HEIGHT_OFFSET");

		public static int TEXT_INPUT_MAX_FONT_SIZE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "TEXT_INPUT_MAX_FONT_SIZE");

		public static int TEXT_INPUT_MIN_FONT_SIZE => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "TEXT_INPUT_MIN_FONT_SIZE");

		public static int TEXT_INPUT_FONT_SIZE_INSET => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "TEXT_INPUT_FONT_SIZE_INSET");

		public static int TEXT_INPUT_IME_FONT_SIZE_INSET => MonoClass.smethod_6<int>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "TEXT_INPUT_IME_FONT_SIZE_INSET");

		public static string TEXT_INPUT_NAME => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "TEXT_INPUT_NAME");

		public static List<GameLayer> HIT_TEST_PRIORITY_ORDER => MonoClass.smethod_7<Class250<GameLayer>>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "HIT_TEST_PRIORITY_ORDER")?.method_25();

		public static bool IsIMEEverUsed => MonoClass.smethod_6<bool>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "IsIMEEverUsed");

		public bool m_mouseOnScreen => method_2<bool>("m_mouseOnScreen");

		public bool m_gameDialogActive => method_2<bool>("m_gameDialogActive");

		public bool m_systemDialogActive => method_2<bool>("m_systemDialogActive");

		public int m_offCameraHitTestMask => method_2<int>("m_offCameraHitTestMask");

		public Camera m_FullscreenEffectsCamera => method_3<Camera>("m_FullscreenEffectsCamera");

		public List<Camera> m_CameraMaskCameras => method_3<Class271<Camera>>("m_CameraMaskCameras")?.method_25();

		public bool m_FullscreenEffectsCameraActive => method_2<bool>("m_FullscreenEffectsCameraActive");

		public List<Camera> m_ignoredCameras => method_3<Class271<Camera>>("m_ignoredCameras")?.method_25();

		public GameObject m_inputOwner => method_3<GameObject>("m_inputOwner");

		public bool m_inputPassword => method_2<bool>("m_inputPassword");

		public bool m_inputNumber => method_2<bool>("m_inputNumber");

		public bool m_inputMultiLine => method_2<bool>("m_inputMultiLine");

		public bool m_inputActive => method_2<bool>("m_inputActive");

		public bool m_inputFocused => method_2<bool>("m_inputFocused");

		public bool m_inputKeepFocusOnComplete => method_2<bool>("m_inputKeepFocusOnComplete");

		public string m_inputText => method_4("m_inputText");

		public Rect m_inputNormalizedRect => method_2<Rect>("m_inputNormalizedRect");

		public Vector2 m_inputInitialScreenSize => method_2<Vector2>("m_inputInitialScreenSize");

		public int m_inputMaxCharacters => method_2<int>("m_inputMaxCharacters");

		public TextAnchor m_inputAlignment => method_2<TextAnchor>("m_inputAlignment");

		public TextAnchor m_defaultInputAlignment => method_2<TextAnchor>("m_defaultInputAlignment");

		public bool m_inputNeedsFocus => method_2<bool>("m_inputNeedsFocus");

		public bool m_tabKeyDown => method_2<bool>("m_tabKeyDown");

		public bool m_inputNeedsFocusFromTabKeyDown => method_2<bool>("m_inputNeedsFocusFromTabKeyDown");

		public TextInputIgnoreState m_inputIgnoreState => method_2<TextInputIgnoreState>("m_inputIgnoreState");

		public bool m_hideVirtualKeyboardOnComplete => method_2<bool>("m_hideVirtualKeyboardOnComplete");

		public GUISkinContainer m_skinContainer => method_3<GUISkinContainer>("m_skinContainer");

		public UniversalInputManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public UniversalInputManager(IntPtr address)
			: this(address, "UniversalInputManager")
		{
		}

		public static UniversalInputManager Get()
		{
			return MonoClass.smethod_15<UniversalInputManager>(TritonHs.MainAssemblyPath, "", "UniversalInputManager", "Get", Array.Empty<object>());
		}

		public void Update()
		{
			method_8("Update");
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void OnGUI()
		{
			method_8("OnGUI");
		}

		public void SetGUISkin(GUISkinContainer skinContainer)
		{
			method_8("SetGUISkin", skinContainer);
		}

		public bool IsTouchMode()
		{
			return method_11<bool>("IsTouchMode", Array.Empty<object>());
		}

		public bool UseWindowsTouch()
		{
			return method_11<bool>("UseWindowsTouch", Array.Empty<object>());
		}

		public bool WasTouchCanceled()
		{
			return method_11<bool>("WasTouchCanceled", Array.Empty<object>());
		}

		public bool IsMouseOnScreen()
		{
			return method_11<bool>("IsMouseOnScreen", Array.Empty<object>());
		}

		public void SetGameDialogActive(bool active)
		{
			method_8("SetGameDialogActive", active);
		}

		public void SetSystemDialogActive(bool active)
		{
			method_8("SetSystemDialogActive", active);
		}

		public void UseTextInput(TextInputParams parms, bool force)
		{
			method_8("UseTextInput", parms, force);
		}

		public void CancelTextInput(GameObject requester, bool force)
		{
			method_9("CancelTextInput", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean
			}, requester, force);
		}

		public void FocusTextInput(GameObject owner)
		{
			method_8("FocusTextInput", owner);
		}

		public void UpdateTextInputRect(GameObject owner, Rect rect)
		{
			method_8("UpdateTextInputRect", owner, rect);
		}

		public bool IsTextInputPassword()
		{
			return method_11<bool>("IsTextInputPassword", Array.Empty<object>());
		}

		public bool IsTextInputActive()
		{
			return method_11<bool>("IsTextInputActive", Array.Empty<object>());
		}

		public string GetInputText()
		{
			return method_13("GetInputText");
		}

		public void SetInputText(string text, bool moveCursorToEnd)
		{
			method_8("SetInputText", text, moveCursorToEnd);
		}

		public bool InputIsOver(GameObject gameObj)
		{
			return method_10<bool>("InputIsOver", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { gameObj });
		}

		public bool InputIsOver(Camera camera, GameObject gameObj)
		{
			return method_10<bool>("InputIsOver", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, new object[2] { camera, gameObj });
		}

		public bool ForcedInputIsOver(Camera camera, GameObject gameObj)
		{
			return method_10<bool>("ForcedInputIsOver", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Class
			}, new object[2] { camera, gameObj });
		}

		public bool InputHitAnyObject(GameLayer layer)
		{
			return method_10<bool>("InputHitAnyObject", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { layer });
		}

		public bool InputHitAnyObject(LayerMask layerMask)
		{
			return method_10<bool>("InputHitAnyObject", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { layerMask });
		}

		public bool InputHitAnyObject(Camera requestedCamera)
		{
			return method_10<bool>("InputHitAnyObject", new Class276.Enum20[1] { Class276.Enum20.Class }, new object[1] { requestedCamera });
		}

		public bool InputHitAnyObject(Camera requestedCamera, GameLayer layer)
		{
			return method_10<bool>("InputHitAnyObject", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { requestedCamera, layer });
		}

		public bool InputHitAnyObject(Camera requestedCamera, LayerMask mask)
		{
			return method_10<bool>("InputHitAnyObject", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { requestedCamera, mask });
		}

		public bool CanHitTestOffCamera(GameLayer layer)
		{
			return method_10<bool>("CanHitTestOffCamera", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { layer });
		}

		public bool CanHitTestOffCamera(LayerMask layerMask)
		{
			return method_10<bool>("CanHitTestOffCamera", new Class276.Enum20[1] { Class276.Enum20.ValueType }, new object[1] { layerMask });
		}

		public void EnableHitTestOffCamera(GameLayer layer, bool enable)
		{
			method_9("EnableHitTestOffCamera", new Class276.Enum20[2]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.Boolean
			}, layer, enable);
		}

		public void EnableHitTestOffCamera(LayerMask mask, bool enable)
		{
			method_9("EnableHitTestOffCamera", new Class276.Enum20[2]
			{
				Class276.Enum20.ValueType,
				Class276.Enum20.Boolean
			}, mask, enable);
		}

		public void SetFullScreenEffectsCamera(Camera camera, bool active)
		{
			method_8("SetFullScreenEffectsCamera", camera, active);
		}

		public bool GetMouseButton(int button)
		{
			return method_11<bool>("GetMouseButton", new object[1] { button });
		}

		public bool GetMouseButtonDown(int button)
		{
			return method_11<bool>("GetMouseButtonDown", new object[1] { button });
		}

		public bool GetMouseButtonUp(int button)
		{
			return method_11<bool>("GetMouseButtonUp", new object[1] { button });
		}

		public Vector3 GetMousePosition()
		{
			return method_11<Vector3>("GetMousePosition", Array.Empty<object>());
		}

		public bool AddCameraMaskCamera(Camera camera)
		{
			return method_11<bool>("AddCameraMaskCamera", new object[1] { camera });
		}

		public bool RemoveCameraMaskCamera(Camera camera)
		{
			return method_11<bool>("RemoveCameraMaskCamera", new object[1] { camera });
		}

		public bool AddIgnoredCamera(Camera camera)
		{
			return method_11<bool>("AddIgnoredCamera", new object[1] { camera });
		}

		public bool RemoveIgnoredCamera(Camera camera)
		{
			return method_11<bool>("RemoveIgnoredCamera", new object[1] { camera });
		}

		public void CreateHitTestPriorityMap()
		{
			method_8("CreateHitTestPriorityMap");
		}

		public void CleanDeadCameras()
		{
			method_8("CleanDeadCameras");
		}

		public Camera GuessBestHitTestCamera(LayerMask mask)
		{
			return method_14<Camera>("GuessBestHitTestCamera", new object[1] { mask });
		}

		public bool HigherPriorityCollisionExists(GameLayer layer)
		{
			return method_11<bool>("HigherPriorityCollisionExists", new object[1] { layer });
		}

		public LayerMask GetHigherPriorityLayerMask(GameLayer layer)
		{
			return method_11<LayerMask>("GetHigherPriorityLayerMask", new object[1] { layer });
		}

		public void UpdateMouseOnOrOffScreen()
		{
			method_8("UpdateMouseOnOrOffScreen");
		}

		public void UpdateInput()
		{
			method_8("UpdateInput");
		}

		public bool UpdateTextInput()
		{
			return method_11<bool>("UpdateTextInput", Array.Empty<object>());
		}

		public void UserCancelTextInput()
		{
			method_8("UserCancelTextInput");
		}

		public void ObjectCancelTextInput(GameObject requester)
		{
			method_8("ObjectCancelTextInput", requester);
		}

		public void CancelTextInput(bool userRequested, GameObject requester)
		{
			method_9("CancelTextInput", new Class276.Enum20[2]
			{
				Class276.Enum20.Boolean,
				Class276.Enum20.Class
			}, userRequested, requester);
		}

		public void CompleteTextInput()
		{
			method_8("CompleteTextInput");
		}

		public void ClearTextInputVars()
		{
			method_8("ClearTextInputVars");
		}

		public bool IgnoreGUIInput()
		{
			return method_11<bool>("IgnoreGUIInput", Array.Empty<object>());
		}

		public void HandleGUIInputInactive()
		{
			method_8("HandleGUIInputInactive");
		}

		public void HandleGUIInputActive()
		{
			method_8("HandleGUIInputActive");
		}

		public bool PreprocessGUITextInput()
		{
			return method_11<bool>("PreprocessGUITextInput", Array.Empty<object>());
		}

		public void UpdateTabKeyDown()
		{
			method_8("UpdateTabKeyDown");
		}

		public bool ProcessTextInputFinishKeys()
		{
			return method_11<bool>("ProcessTextInputFinishKeys", Array.Empty<object>());
		}

		public void SetupTextInput(Vector2 screenSize, Rect inputScreenRect)
		{
			method_8("SetupTextInput", screenSize, inputScreenRect);
		}

		public string ShowTextInput(Rect inputScreenRect)
		{
			return method_13("ShowTextInput", inputScreenRect);
		}

		public void UpdateTextInputFocus()
		{
			method_8("UpdateTextInputFocus");
		}

		public Rect ComputeTextInputRect(Vector2 screenSize)
		{
			return method_11<Rect>("ComputeTextInputRect", new object[1] { screenSize });
		}

		public int ComputeTextInputFontSize(Vector2 screenSize, float rectHeight)
		{
			return method_11<int>("ComputeTextInputFontSize", new object[2] { screenSize, rectHeight });
		}
	}
}
